{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4910a250",
   "metadata": {},
   "source": [
    "## Modified MTGNN with VAE\n",
    "The MTGNN model is modified to return the model state after the last layer. <br />\n",
    "This feature space is used for input reconstruction with a Variational Autoencoder (VAE) <br />\n",
    "and prediction of the next time step with a linear convolution network.<br />\n",
    "\n",
    "The loss is the combination of the VAE and prediction losses: <br />\n",
    "\n",
    "$L_{\\theta, \\Phi} = -\\log (p_\\theta(\\mathbf{x})) + D_{KL}(q_\\Phi(\\mathbf{z\\mid x})\\parallel p_\\theta(\\mathbf{z\\mid x}))$<br />\n",
    "\n",
    "$L_{pred} = \\frac{1}{n}\\sum_{i=1}^n(\\hat{Y_i}-Y_i)^2$<br />\n",
    "<br />\n",
    "\n",
    "#### Graph Learning\n",
    "Graph learning is turned on by default. <br />\n",
    "The model takes a new parameter *graph_type* determining the properties of the <br />\n",
    "learned adjacency matrix. \n",
    "\n",
    "<pre>\n",
    "graph_type='bi'  # creates an unstructured matrix for asymmetrical bi-directional graphs\n",
    "graph_type='uni' # creates a skew-symmetrical matrix for uni-directional graphs (A = -A.T)\n",
    "graph_type='sym' # creates a symmetrical matrix for undirected graphs (A = A.T)\n",
    "</pre>\n",
    "<br />\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1296f01c",
   "metadata": {},
   "source": [
    "### MTGNN Modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3b5a7646",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "\n",
    "from typing import Optional\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import init\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class Linear(nn.Module):\n",
    "    r\"\"\"An implementation of the linear layer, conducting 2D convolution.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        c_in (int): Number of input channels.\n",
    "        c_out (int): Number of output channels.\n",
    "        bias (bool, optional): Whether to have bias. Default: True.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, c_in: int, c_out: int, bias: bool = True):\n",
    "        super(Linear, self).__init__()\n",
    "        self._mlp = torch.nn.Conv2d(\n",
    "            c_in, c_out, kernel_size=(1, 1), padding=(0, 0), stride=(1, 1), bias=bias\n",
    "        )\n",
    "\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def forward(self, X: torch.FloatTensor) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of the linear layer.\n",
    "\n",
    "        Arg types:\n",
    "            * **X** (Pytorch Float Tensor) - Input tensor, with shape (batch_size, c_in, num_nodes, seq_len).\n",
    "\n",
    "        Return types:\n",
    "            * **X** (PyTorch Float Tensor) - Output tensor, with shape (batch_size, c_out, num_nodes, seq_len).\n",
    "        \"\"\"\n",
    "        return self._mlp(X)\n",
    "\n",
    "\n",
    "class MixProp(nn.Module):\n",
    "    r\"\"\"An implementation of the dynatic mix-hop propagation layer.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        c_in (int): Number of input channels.\n",
    "        c_out (int): Number of output channels.\n",
    "        gdep (int): Depth of graph convolution.\n",
    "        dropout (float): Dropout rate.\n",
    "        alpha (float): Ratio of retaining the root nodes's original states, a value between 0 and 1.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, c_in: int, c_out: int, gdep: int, dropout: float, alpha: float):\n",
    "        super(MixProp, self).__init__()\n",
    "        self._mlp = Linear((gdep + 1) * c_in, c_out)\n",
    "        self._gdep = gdep\n",
    "        self._dropout = dropout\n",
    "        self._alpha = alpha\n",
    "\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def forward(self, X: torch.FloatTensor, A: torch.FloatTensor) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of mix-hop propagation.\n",
    "\n",
    "        Arg types:\n",
    "            * **X** (Pytorch Float Tensor) - Input feature Tensor, with shape (batch_size, c_in, num_nodes, seq_len).\n",
    "            * **A** (PyTorch Float Tensor) - Adjacency matrix, with shape (num_nodes, num_nodes).\n",
    "\n",
    "        Return types:\n",
    "            * **H_0** (PyTorch Float Tensor) - Hidden representation for all nodes, with shape (batch_size, c_out, num_nodes, seq_len).\n",
    "        \"\"\"\n",
    "        A = A + torch.eye(A.size(0)).to(X.device)\n",
    "        d = A.sum(1)\n",
    "        H = X\n",
    "        H_0 = X\n",
    "        A = A / d.view(-1, 1)\n",
    "        for _ in range(self._gdep):\n",
    "            print(H.shape, A.shape)\n",
    "            H = self._alpha * X + (1 - self._alpha) * torch.einsum(\n",
    "                \"ncwl,vw->ncvl\", (H, A)\n",
    "            )\n",
    "            H_0 = torch.cat((H_0, H), dim=1)\n",
    "        H_0 = self._mlp(H_0)\n",
    "        return H_0\n",
    "\n",
    "\n",
    "class DilatedInception(nn.Module):\n",
    "    r\"\"\"An implementation of the dilated inception layer.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        c_in (int): Number of input channels.\n",
    "        c_out (int): Number of output channels.\n",
    "        kernel_set (list of int): List of kernel sizes.\n",
    "        dilated_factor (int, optional): Dilation factor.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, c_in: int, c_out: int, kernel_set: list, dilation_factor: int):\n",
    "        super(DilatedInception, self).__init__()\n",
    "        self._time_conv = nn.ModuleList()\n",
    "        self._kernel_set = kernel_set\n",
    "        c_out = int(c_out / len(self._kernel_set))\n",
    "        for kern in self._kernel_set:\n",
    "            self._time_conv.append(\n",
    "                nn.Conv2d(c_in, c_out, (1, kern), dilation=(1, dilation_factor))\n",
    "            )\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def forward(self, X_in: torch.FloatTensor) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of dilated inception.\n",
    "\n",
    "        Arg types:\n",
    "            * **X_in** (Pytorch Float Tensor) - Input feature Tensor, with shape (batch_size, c_in, num_nodes, seq_len).\n",
    "\n",
    "        Return types:\n",
    "            * **X** (PyTorch Float Tensor) - Hidden representation for all nodes,\n",
    "            with shape (batch_size, c_out, num_nodes, seq_len-6).\n",
    "        \"\"\"\n",
    "        X = []\n",
    "        for i in range(len(self._kernel_set)):\n",
    "            X.append(self._time_conv[i](X_in))\n",
    "        for i in range(len(self._kernel_set)):\n",
    "            X[i] = X[i][..., -X[-1].size(3) :]\n",
    "        X = torch.cat(X, dim=1)\n",
    "        return X\n",
    "\n",
    "\n",
    "class GraphConstructor(nn.Module):\n",
    "    r\"\"\"An implementation of the graph learning layer to construct an adjacency matrix.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        nnodes (int): Number of nodes in the graph.\n",
    "        topk (int): Number of largest values to consider in constructing the neighbourhood of a node (pick the \"nearest\" k nodes).\n",
    "        dim (int): Dimension of the node embedding.\n",
    "        alpha (float, optional): Tanh alpha for generating adjacency matrix, alpha controls the saturation rate\n",
    "        # xd (int, optional): Static feature dimension, default None.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, nnodes: int, topk: int, dim: int, alpha: float, type: Optional[str] = 'bi'\n",
    "    ):\n",
    "        super(GraphConstructor, self).__init__()\n",
    "        \n",
    "        self._embedding1 = nn.Embedding(nnodes, dim)\n",
    "        self._embedding2 = nn.Embedding(nnodes, dim)\n",
    "        self._linear1 = nn.Linear(dim, dim)\n",
    "        self._linear2 = nn.Linear(dim, dim)\n",
    "\n",
    "        self._nnodes = nnodes\n",
    "        self._topk = topk\n",
    "        self._alpha = alpha\n",
    "\n",
    "        assert type in ['bi', 'uni', 'sym']\n",
    "        self.graph_type = type\n",
    "\n",
    "        self._A = None\n",
    "\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def get_A(self):\n",
    "        if self._A is None:\n",
    "            return self.forward()\n",
    "        else:\n",
    "            return self._A\n",
    "\n",
    "    def forward(self) -> torch.FloatTensor:\n",
    "        #self, idx: torch.LongTensor, FE: Optional[torch.FloatTensor] = None\n",
    "    \n",
    "        \"\"\"\n",
    "        Making a forward pass to construct an adjacency matrix from node embeddings.\n",
    "\n",
    "        Arg types:\n",
    "            # * **idx** (Pytorch Long Tensor) - Input indices, a permutation of the number of nodes, default None (no permutation).\n",
    "            # * **FE** (Pytorch Float Tensor, optional) - Static feature, default None.\n",
    "        Return types:\n",
    "            * **A** (PyTorch Float Tensor) - Adjacency matrix constructed from node embeddings.\n",
    "        \"\"\"\n",
    "        \n",
    "        M1 = self._embedding1.weight.clone()\n",
    "        M2 = self._embedding2.weight.clone()\n",
    "\n",
    "        M1 = torch.tanh(self._alpha * self._linear1(M1))\n",
    "        M2 = torch.tanh(self._alpha * self._linear2(M2))\n",
    "\n",
    "        if self.graph_type is 'uni':\n",
    "\n",
    "            a = torch.mm(M1, M2.transpose(1, 0)) - torch.mm(M2, M1.transpose(1, 0))\n",
    "\n",
    "        elif self.graph_type is 'bi':\n",
    "            a = torch.mm(M1, M2.transpose(1, 0)) \n",
    "            a.fill_diagonal_(0)\n",
    "\n",
    "        elif self.graph_type is 'sym':\n",
    "            a = torch.mm(M1, M1.transpose(1, 0)) - torch.mm(M2, M2.transpose(1, 0))\n",
    "            a.fill_diagonal_(0)\n",
    "        \n",
    "        A = F.relu(torch.tanh(self._alpha * a))\n",
    "        mask = torch.zeros(self._nnodes, self._nnodes).to(A.device)\n",
    "        mask.fill_(float(\"0\"))\n",
    "        s1, t1 = A.topk(self._topk, 1)\n",
    "        mask.scatter_(1, t1, s1.fill_(1))\n",
    "        A = A * mask\n",
    "        return A\n",
    "\n",
    "\n",
    "class LayerNormalization(nn.Module):\n",
    "    __constants__ = [\"normalized_shape\", \"weight\", \"bias\", \"eps\", \"elementwise_affine\"]\n",
    "    r\"\"\"An implementation of the layer normalization layer.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\" \n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        normalized_shape (int): Input shape from an expected input of size.\n",
    "        eps (float, optional): Value added to the denominator for numerical stability. Default: 1e-5.\n",
    "        elementwise_affine (bool, optional): Whether to conduct elementwise affine transformation or not. Default: True.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, normalized_shape: int, eps: float = 1e-5, elementwise_affine: bool = True\n",
    "    ):\n",
    "        super(LayerNormalization, self).__init__()\n",
    "        self._normalized_shape = tuple(normalized_shape)\n",
    "        self._eps = eps\n",
    "        self._elementwise_affine = elementwise_affine\n",
    "        if self._elementwise_affine:\n",
    "            self._weight = nn.Parameter(torch.Tensor(*normalized_shape))\n",
    "            self._bias = nn.Parameter(torch.Tensor(*normalized_shape))\n",
    "        else:\n",
    "            self.register_parameter(\"_weight\", None)\n",
    "            self.register_parameter(\"_bias\", None)\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        if self._elementwise_affine:\n",
    "            init.ones_(self._weight)\n",
    "            init.zeros_(self._bias)\n",
    "\n",
    "    def forward(self, X: torch.FloatTensor) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of layer normalization.\n",
    "\n",
    "        Arg types:\n",
    "            * **X** (Pytorch Float Tensor) - Input tensor,\n",
    "                with shape (batch_size, feature_dim, num_nodes, seq_len).\n",
    "            * **idx** (Pytorch Long Tensor) - Input indices.\n",
    "\n",
    "        Return types:\n",
    "            * **X** (PyTorch Float Tensor) - Output tensor,\n",
    "                with shape (batch_size, feature_dim, num_nodes, seq_len).\n",
    "        \"\"\"\n",
    "        if self._elementwise_affine:\n",
    "            return F.layer_norm(\n",
    "                X,\n",
    "                tuple(X.shape[1:]),\n",
    "                self._weight,\n",
    "                self._bias,\n",
    "                self._eps,\n",
    "            )\n",
    "        else:\n",
    "            return F.layer_norm(\n",
    "                X, tuple(X.shape[1:]), self._weight, self._bias, self._eps\n",
    "            )\n",
    "\n",
    "\n",
    "class MTGNNLayer(nn.Module):\n",
    "    r\"\"\"An implementation of the MTGNN layer.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        dilation_exponential (int): Dilation exponential.\n",
    "        rf_size_i (int): Size of receptive field.\n",
    "        kernel_size (int): Size of kernel for convolution, to calculate receptive field size.\n",
    "        j (int): Iteration index.\n",
    "        residual_channels (int): Residual channels.\n",
    "        conv_channels (int): Convolution channels.\n",
    "        skip_channels (int): Skip channels.\n",
    "        kernel_set (list of int): List of kernel sizes.\n",
    "        new_dilation (int): Dilation.\n",
    "        layer_norm_affline (bool): Whether to do elementwise affine in Layer Normalization.\n",
    "        # gcn_true (bool): Whether to add graph convolution layer.\n",
    "        seq_length (int): Length of input sequence.\n",
    "        receptive_field (int): Receptive field.\n",
    "        dropout (float): Droupout rate.\n",
    "        gcn_depth (int): Graph convolution depth.\n",
    "        num_nodes (int): Number of nodes in the graph.\n",
    "        propalpha (float): Prop alpha, ratio of retaining the root nodes's original states in mix-hop propagation, a value between 0 and 1.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        dilation_exponential: int,\n",
    "        rf_size_i: int,\n",
    "        kernel_size: int,\n",
    "        j: int,\n",
    "        residual_channels: int,\n",
    "        conv_channels: int,\n",
    "        skip_channels: int,\n",
    "        kernel_set: list,\n",
    "        new_dilation: int,\n",
    "        layer_norm_affline: bool,\n",
    "        # gcn_true: bool,\n",
    "        seq_length: int,\n",
    "        receptive_field: int,\n",
    "        dropout: float,\n",
    "        gcn_depth: int,\n",
    "        num_nodes: int,\n",
    "        propalpha: float,\n",
    "    ):\n",
    "        super(MTGNNLayer, self).__init__()\n",
    "        self._dropout = dropout\n",
    "        # self._gcn_true = gcn_true\n",
    "\n",
    "        if dilation_exponential > 1:\n",
    "            rf_size_j = int(\n",
    "                rf_size_i\n",
    "                + (kernel_size - 1)\n",
    "                * (dilation_exponential ** j - 1)\n",
    "                / (dilation_exponential - 1)\n",
    "            )\n",
    "        else:\n",
    "            rf_size_j = rf_size_i + j * (kernel_size - 1)\n",
    "\n",
    "        self._filter_conv = DilatedInception(\n",
    "            residual_channels,\n",
    "            conv_channels,\n",
    "            kernel_set=kernel_set,\n",
    "            dilation_factor=new_dilation,\n",
    "        )\n",
    "\n",
    "        self._gate_conv = DilatedInception(\n",
    "            residual_channels,\n",
    "            conv_channels,\n",
    "            kernel_set=kernel_set,\n",
    "            dilation_factor=new_dilation,\n",
    "        )\n",
    "             \n",
    "        if seq_length > receptive_field:\n",
    "            self._skip_conv = nn.Conv2d(\n",
    "                in_channels=conv_channels,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, seq_length - rf_size_j + 1),\n",
    "            )\n",
    "        else:\n",
    "            self._skip_conv = nn.Conv2d(\n",
    "                in_channels=conv_channels,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, receptive_field - rf_size_j + 1),\n",
    "            )\n",
    "\n",
    "        # if gcn_true:\n",
    "        self._mixprop_conv1 = MixProp(\n",
    "            conv_channels, residual_channels, gcn_depth, dropout, propalpha\n",
    "        )\n",
    "\n",
    "        self._mixprop_conv2 = MixProp(\n",
    "            conv_channels, residual_channels, gcn_depth, dropout, propalpha\n",
    "        )\n",
    "\n",
    "        if seq_length > receptive_field:\n",
    "            self._normalization = LayerNormalization(\n",
    "                (residual_channels, num_nodes, seq_length - rf_size_j + 1),\n",
    "                elementwise_affine=layer_norm_affline,\n",
    "            )\n",
    "\n",
    "        else:\n",
    "            self._normalization = LayerNormalization(\n",
    "                (residual_channels, num_nodes, receptive_field - rf_size_j + 1),\n",
    "                elementwise_affine=layer_norm_affline,\n",
    "            )\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        X: torch.FloatTensor,\n",
    "        X_skip: torch.FloatTensor,\n",
    "        A_tilde: Optional[torch.FloatTensor],\n",
    "        # idx: torch.LongTensor,\n",
    "        training: bool,\n",
    "    ) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of MTGNN layer.\n",
    "\n",
    "        Arg types:\n",
    "            * **X** (PyTorch FloatTensor) - Input feature tensor,\n",
    "                with shape (batch_size, in_dim, num_nodes, seq_len).\n",
    "            * **X_skip** (PyTorch FloatTensor) - Input feature tensor for skip connection,\n",
    "                with shape (batch_size, in_dim, num_nodes, seq_len).\n",
    "            * **A_tilde** (Pytorch FloatTensor or None) - Predefined adjacency matrix.\n",
    "            # * **idx** (Pytorch LongTensor) - Input indices.\n",
    "            * **training** (bool) - Whether in traning mode.\n",
    "\n",
    "        Return types:\n",
    "            * **X** (PyTorch FloatTensor) - Output sequence tensor,\n",
    "                with shape (batch_size, seq_len, num_nodes, seq_len).\n",
    "            * **X_skip** (PyTorch FloatTensor) - Output feature tensor for skip connection,\n",
    "                with shape (batch_size, in_dim, num_nodes, seq_len).\n",
    "        \"\"\"\n",
    "        X_residual = X\n",
    "        X_filter = self._filter_conv(X)\n",
    "        X_filter = torch.tanh(X_filter)\n",
    "        X_gate = self._gate_conv(X)\n",
    "        X_gate = torch.sigmoid(X_gate)\n",
    "        X = X_filter * X_gate\n",
    "        \n",
    "        X = F.dropout(X, self._dropout, training=training)\n",
    "        X_skip = self._skip_conv(X) + X_skip\n",
    "        X = self._mixprop_conv1(X, A_tilde) + self._mixprop_conv2(\n",
    "            X, A_tilde.transpose(1, 0)\n",
    "        )\n",
    "        X = X + X_residual[:, :, :, -X.size(3) :]\n",
    "\n",
    "        X = self._normalization(X)\n",
    "        return X, X_skip\n",
    "\n",
    "\n",
    "class MTGNN(nn.Module):\n",
    "    r\"\"\"An implementation of the Multivariate Time Series Forecasting Graph Neural Networks.\n",
    "    For details see this paper: `\"Connecting the Dots: Multivariate Time Series Forecasting with Graph Neural Networks.\"\n",
    "    <https://arxiv.org/pdf/2005.11650.pdf>`_\n",
    "\n",
    "    Args:\n",
    "        # gcn_true (bool): Whether to add graph convolution layer.\n",
    "        # build_adj (bool): Whether to construct adaptive adjacency matrix.\n",
    "        gcn_depth (int): Graph convolution depth.\n",
    "        num_nodes (int): Number of nodes in the graph.\n",
    "        kernel_set (list of int): List of kernel sizes.\n",
    "        kernel_size (int): Size of kernel for convolution, to calculate receptive field size.\n",
    "        dropout (float): Droupout rate.\n",
    "        topk (int): Size of subgraph.\n",
    "        node_embedding_dim (int): Dimension of nodes.\n",
    "        dilation_exponential (int): Dilation exponential.\n",
    "        conv_channels (int): Convolution channels.\n",
    "        residual_channels (int): Residual channels.\n",
    "        skip_channels (int): Skip channels.\n",
    "        out_channels (int): End channels.\n",
    "        seq_length (int): Length of input sequence.\n",
    "        in_dim (int): Input dimension.\n",
    "        # out_dim (int): Output dimension.\n",
    "        layers (int): Number of layers.\n",
    "        propalpha (float): Prop alpha, ratio of retaining the root nodes's original states in mix-hop propagation, a value between 0 and 1.\n",
    "        tanhalpha (float): Tanh alpha for generating adjacency matrix, alpha controls the saturation rate.\n",
    "        layer_norm_affline (bool): Whether to do elementwise affine in Layer Normalization.\n",
    "        # xd (int, optional): Static feature dimension, default None.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        gcn_depth: int,\n",
    "        num_nodes: int,\n",
    "        kernel_set: list,\n",
    "        kernel_size: int,\n",
    "        dropout: float,\n",
    "        topk: int,\n",
    "        node_embedding_dim: int,\n",
    "        dilation_exponential: int,\n",
    "        conv_channels: int,\n",
    "        residual_channels: int,\n",
    "        skip_channels: int,\n",
    "        out_channels: int,\n",
    "        seq_length: int,\n",
    "        in_dim: int,\n",
    "        layers: int,\n",
    "        propalpha: float,\n",
    "        tanhalpha: float,\n",
    "        layer_norm_affline: bool,\n",
    "        graph_type: Optional[str] = 'bi',\n",
    "    ):\n",
    "        super(MTGNN, self).__init__()\n",
    "\n",
    "        self._num_nodes = num_nodes\n",
    "        self._dropout = dropout\n",
    "        self._seq_length = seq_length\n",
    "        self._layers = layers\n",
    "\n",
    "        self._mtgnn_layers = nn.ModuleList()\n",
    "\n",
    "        self._graph_constructor = GraphConstructor(\n",
    "            num_nodes, topk, node_embedding_dim, alpha=tanhalpha, type=graph_type\n",
    "        )\n",
    "\n",
    "        self._set_receptive_field(dilation_exponential, kernel_size, layers)\n",
    "\n",
    "        new_dilation = 1\n",
    "        for j in range(1, layers + 1):\n",
    "            self._mtgnn_layers.append(\n",
    "                MTGNNLayer(\n",
    "                    dilation_exponential=dilation_exponential,\n",
    "                    rf_size_i=1,\n",
    "                    kernel_size=kernel_size,\n",
    "                    j=j,\n",
    "                    residual_channels=residual_channels,\n",
    "                    conv_channels=conv_channels,\n",
    "                    skip_channels=skip_channels,\n",
    "                    kernel_set=kernel_set,\n",
    "                    new_dilation=new_dilation,\n",
    "                    layer_norm_affline=layer_norm_affline,\n",
    "                    seq_length=seq_length,\n",
    "                    receptive_field=self._receptive_field,\n",
    "                    dropout=dropout,\n",
    "                    gcn_depth=gcn_depth,\n",
    "                    num_nodes=num_nodes,\n",
    "                    propalpha=propalpha,\n",
    "                )\n",
    "            )\n",
    "\n",
    "            new_dilation *= dilation_exponential\n",
    "\n",
    "        self._setup_conv(in_dim, skip_channels, out_channels, residual_channels)\n",
    "\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _setup_conv(self, in_dim, skip_channels, out_channels, residual_channels):\n",
    "\n",
    "        self._start_conv = nn.Conv2d(\n",
    "            in_channels=in_dim, out_channels=residual_channels, kernel_size=(1, 1)\n",
    "        )\n",
    "\n",
    "        if self._seq_length > self._receptive_field:\n",
    "\n",
    "            self._skip_conv_0 = nn.Conv2d(\n",
    "                in_channels=in_dim,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, self._seq_length),\n",
    "                bias=True,\n",
    "            )\n",
    "\n",
    "            self._skip_conv_E = nn.Conv2d(\n",
    "                in_channels=residual_channels,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, self._seq_length - self._receptive_field + 1),\n",
    "                bias=True,\n",
    "            )\n",
    "\n",
    "        else:\n",
    "            self._skip_conv_0 = nn.Conv2d(\n",
    "                in_channels=in_dim,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, self._receptive_field),\n",
    "                bias=True,\n",
    "            )\n",
    "\n",
    "            self._skip_conv_E = nn.Conv2d(\n",
    "                in_channels=residual_channels,\n",
    "                out_channels=skip_channels,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            )\n",
    "\n",
    "        self._out_conv = nn.Sequential(\n",
    "            nn.Conv2d(\n",
    "                in_channels=skip_channels,\n",
    "                out_channels=out_channels,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            ),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "        )\n",
    "\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        for p in self.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "            else:\n",
    "                nn.init.uniform_(p)\n",
    "\n",
    "    def _set_receptive_field(self, dilation_exponential, kernel_size, layers):\n",
    "        if dilation_exponential > 1:\n",
    "            self._receptive_field = int(\n",
    "                1\n",
    "                + (kernel_size - 1)\n",
    "                * (dilation_exponential ** layers - 1)\n",
    "                / (dilation_exponential - 1)\n",
    "            )\n",
    "        else:\n",
    "            self._receptive_field = layers * (kernel_size - 1) + 1\n",
    "\n",
    "    def get_adjacency_matrix(self):\n",
    "        return self._graph_constructor.get_A()\n",
    "\n",
    "    def forward(self, X_in: torch.FloatTensor) -> torch.FloatTensor:\n",
    "        \"\"\"\n",
    "        Making a forward pass of MTGNN.\n",
    "\n",
    "        Arg types:\n",
    "            * **X_in** (PyTorch FloatTensor) - Input sequence, with shape (batch_size, in_dim, num_nodes, seq_len).\n",
    "            # * **A_tilde** (Pytorch FloatTensor, optional) - Predefined adjacency matrix, default None.\n",
    "            # * **idx** (Pytorch LongTensor, optional) - Input indices, a permutation of the num_nodes, default None (no permutation).\n",
    "            # * **FE** (Pytorch FloatTensor, optional) - Static feature, default None.\n",
    "\n",
    "        Return types:\n",
    "            * **X** (PyTorch FloatTensor) - Output sequence for prediction, with shape (batch_size, seq_len, num_nodes, 1).\n",
    "        \"\"\"\n",
    "        seq_len = X_in.size(3)\n",
    "        assert (seq_len == self._seq_length), \"Input sequence length not equal to preset sequence length.\"\n",
    "\n",
    "        if self._seq_length < self._receptive_field:\n",
    "            X_in = F.pad(\n",
    "                X_in, (self._receptive_field - self._seq_length, 0, 0, 0)\n",
    "            )\n",
    "\n",
    "        A_tilde = self._graph_constructor()\n",
    "                \n",
    "        X = self._start_conv(X_in)\n",
    "        X_skip = self._skip_conv_0(\n",
    "            F.dropout(X_in, self._dropout, training=self.training)\n",
    "        )\n",
    "        \n",
    "        for mtgnn in self._mtgnn_layers:\n",
    "            X, X_skip = mtgnn(X, X_skip, A_tilde, self.training)     \n",
    "        \n",
    "        X_skip = F.relu(self._skip_conv_E(X) + X_skip)\n",
    "        \n",
    "        return F.leaky_relu(self._out_conv(X_skip))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c53a983",
   "metadata": {},
   "source": [
    "### MTGNN VAE+Pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "70fccf87",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [05:21<00:00,  1.55it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train MSE: Prediction: 0.0601 - Reconstruction: 0.0602\n",
      "Test MSE: Prediction: 0.8477 - Reconstruction: 0.0552\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch_geometric_temporal.dataset import ChickenpoxDatasetLoader\n",
    "from torch_geometric_temporal.signal import temporal_signal_split\n",
    "\n",
    "from torch_geometric.data import DataLoader\n",
    "\n",
    "loader = ChickenpoxDatasetLoader()\n",
    "\n",
    "lags = 10\n",
    "stride = 1\n",
    "epochs = 500\n",
    "batch_size = 32\n",
    "\n",
    "dataset = loader.get_dataset(lags)\n",
    "\n",
    "sample = next(iter(dataset))\n",
    "num_nodes = sample.x.size(0)\n",
    "\n",
    "train_dataset, test_dataset = temporal_signal_split(dataset, train_ratio=0.2)\n",
    "\n",
    "train_loader = DataLoader(list(train_dataset), batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(list(test_dataset), batch_size=batch_size, shuffle=False)\n",
    "\n",
    "### MODEL DEFINITION\n",
    "class GNN_VAE(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(GNN_VAE, self).__init__()\n",
    "\n",
    "        out_channels = 32\n",
    "        latent_dim = 32\n",
    "\n",
    "        self.gnn = MTGNN(\n",
    "            gcn_depth=3,\n",
    "            num_nodes=num_nodes,\n",
    "            kernel_set=[5,5,5],\n",
    "            kernel_size=5,\n",
    "            dropout=0.2,\n",
    "            topk=5,\n",
    "            node_embedding_dim=64,\n",
    "            dilation_exponential=2,\n",
    "            conv_channels=30,\n",
    "            residual_channels=32,\n",
    "            skip_channels=32,\n",
    "            out_channels=out_channels,\n",
    "            seq_length=lags,\n",
    "            in_dim=1,\n",
    "            layers=2,\n",
    "            propalpha=0.2,\n",
    "            tanhalpha=0.5,\n",
    "            layer_norm_affline=True,\n",
    "            graph_type='bi'\n",
    "        )\n",
    "\n",
    "        self.prediction = nn.Sequential(\n",
    "            nn.Conv2d(\n",
    "                in_channels=out_channels,\n",
    "                out_channels=64,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            ), \n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(\n",
    "                in_channels=64,\n",
    "                out_channels=128,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            ),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(\n",
    "                in_channels=128,\n",
    "                out_channels=1,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        self.vae_encoder = nn.Sequential(\n",
    "            nn.Conv2d(\n",
    "                in_channels=out_channels,\n",
    "                out_channels=128,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            ), \n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(\n",
    "                in_channels=128,\n",
    "                out_channels=64,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            ), \n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(\n",
    "                in_channels=64,\n",
    "                out_channels=2*latent_dim,\n",
    "                kernel_size=(1, 1),\n",
    "                bias=True,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        self.vae_decoder = nn.Sequential(\n",
    "                nn.Conv2d(\n",
    "                    in_channels=latent_dim,\n",
    "                    out_channels=64,\n",
    "                    kernel_size=(1, 1),\n",
    "                    bias=True,\n",
    "                ),\n",
    "                nn.BatchNorm2d(64),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(\n",
    "                    in_channels=64,\n",
    "                    out_channels=128,\n",
    "                    kernel_size=(1, 1),\n",
    "                    bias=True,\n",
    "                ),\n",
    "                nn.BatchNorm2d(128),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(\n",
    "                    in_channels=128,\n",
    "                    out_channels=2*lags,\n",
    "                    kernel_size=(1, 1),\n",
    "                    bias=True,\n",
    "                )\n",
    "            )\n",
    "        self.bn = nn.BatchNorm2d(lags)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        # (batch, 1, num_nodes, lags)\n",
    "        x = x.permute(0,3,2,1)\n",
    "        x = self.bn(x)\n",
    "        x = x.permute(0,3,2,1)\n",
    "\n",
    "        B, _, N, T = x.shape     \n",
    "        h = self.gnn(x) # (batch, out_channels, num_nodes, 1)\n",
    "        # print(x.shape)\n",
    "        \n",
    "        mu_z, logvar_z = self.vae_encoder(h).chunk(2, dim=1)\n",
    "        std_z = torch.exp(0.5 * logvar_z)\n",
    "        kld = torch.mean(-0.5 * torch.mean(1 + logvar_z - (mu_z ** 2) - logvar_z.exp(), dim = 1))\n",
    "\n",
    "        eps = torch.rand_like(std_z)\n",
    "        K = 5\n",
    "        z = torch.stack([std_z * eps + mu_z for _ in range(K)], dim=0)\n",
    "        K, B, C, N, _ = z.shape\n",
    "        z = z.view(K*B, C, N, -1)\n",
    "        \n",
    "        mu_x, logvar_x = self.vae_decoder(z).permute(0,3,2,1).contiguous().view(K,B,1,N,2*T).chunk(2, dim=4)\n",
    "        \n",
    "        y_hat = self.prediction(h).squeeze(-1).permute(0,2,1).flatten()      \n",
    "\n",
    "        return y_hat, mu_x, logvar_x, kld\n",
    "    \n",
    "model = GNN_VAE()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
    "kld_weight = 1\n",
    "\n",
    "### TRAIN\n",
    "model.train()\n",
    "\n",
    "pred_loss_history = []\n",
    "rec_loss_history = []\n",
    "for _ in tqdm(range(epochs)):\n",
    "    total_pred_loss = 0\n",
    "    total_rec_loss = 0\n",
    "    for i, window in enumerate(train_loader):\n",
    "        x = window.x.view(-1, 1, num_nodes, lags)\n",
    "        y = window.y\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        y_pred, mu_x, logvar_x, kld = model(x)\n",
    "\n",
    "        log_likelihood = -((x.unsqueeze(0) - mu_x) ** 2) / (2 * torch.exp(logvar_x)) - logvar_x - math.log(math.sqrt(2 * math.pi))\n",
    "               \n",
    "        assert y_pred.shape == y.shape\n",
    "\n",
    "        pred_loss = torch.mean((y_pred - y)**2)\n",
    "        vae_loss = kld_weight * kld - log_likelihood.mean()\n",
    "\n",
    "        loss = pred_loss + vae_loss\n",
    "\n",
    "        total_pred_loss += pred_loss.item()\n",
    "        total_rec_loss += torch.mean((mu_x - x)**2).item()\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    total_rec_loss /= i+1\n",
    "    total_pred_loss /= i+1\n",
    "\n",
    "    pred_loss_history.append(total_pred_loss)\n",
    "    rec_loss_history.append(total_rec_loss)\n",
    "\n",
    "### TEST \n",
    "model.eval()\n",
    "pred_loss = 0\n",
    "rec_loss = 0\n",
    "with torch.no_grad():\n",
    "    for i, window in enumerate(test_loader):\n",
    "        x = window.x.view(-1, 1, num_nodes, lags)\n",
    "        y = window.y\n",
    "\n",
    "        y_pred, mu_x, logvar_x, kld = model(x)\n",
    "\n",
    "        log_likelihood = -((x - mu_x) ** 2) / (2 * torch.exp(logvar_x)) - logvar_x - math.log(math.sqrt(2 * math.pi))\n",
    "        \n",
    "        assert y_pred.shape == y.shape\n",
    "\n",
    "        pred_loss += torch.mean((y_pred - y)**2).item()\n",
    "        rec_loss += torch.mean((mu_x - x)**2).item()\n",
    "        \n",
    "    pred_loss /= i+1\n",
    "    rec_loss /= i+1\n",
    "\n",
    "### RESULTS PLOT\n",
    "colors = ['#2300a8', '#8400a8'] # '#8400a8', '#00A658'\n",
    "plot_dict = {'Prediction': (pred_loss_history, colors[0]), 'Reconstruction': (rec_loss_history, colors[1])}\n",
    "\n",
    "n = len(pred_loss_history)\n",
    "\n",
    "# plot train and val losses and log_likelihood area under the curve\n",
    "fig, ax = plt.subplots()\n",
    "x_axis = list(range(1, n+1))\n",
    "for key, (data, color) in plot_dict.items():\n",
    "    ax.plot(x_axis, data, \n",
    "                label=key, \n",
    "                linewidth=2, \n",
    "                linestyle='-', \n",
    "                alpha=1, \n",
    "                color=color)\n",
    "    ax.fill_between(x_axis, data, \n",
    "                alpha=0.3, \n",
    "                color=color)\n",
    "\n",
    "# figure labels\n",
    "ax.set_title('Loss over time', fontweight='bold')\n",
    "ax.set_xlabel('Epochs', fontweight='bold')\n",
    "ax.set_ylabel('Mean Squared Error', fontweight='bold')\n",
    "ax.legend(loc='upper right')\n",
    "\n",
    "# remove top and right borders\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "\n",
    "# adds major gridlines\n",
    "ax.grid(color='grey', linestyle='-', linewidth=0.35, alpha=0.8)\n",
    "\n",
    "# y-axis in log scale (reconstruction loss tends to start high)\n",
    "# ax.set_yscale('log')\n",
    "plt.show()\n",
    "\n",
    "print(\"Train MSE: Prediction: {:.4f} - Reconstruction: {:.4f}\".format(pred_loss_history[-1], rec_loss_history[-1]))\n",
    "print(\"Test MSE: Prediction: {:.4f} - Reconstruction: {:.4f}\".format(pred_loss, rec_loss))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffaed29e",
   "metadata": {},
   "source": [
    "### Learned Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "605c7dc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "A = model.gnn.get_adjacency_matrix()\n",
    "G = nx.from_numpy_matrix(np.matrix(A.detach()), create_using=nx.DiGraph)\n",
    "\n",
    "layout = nx.spring_layout(G)\n",
    "nx.draw(G, layout, with_labels = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33ed1729",
   "metadata": {},
   "source": [
    "### True Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9036013f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "edge_indices = dataset.edge_index\n",
    "edge_list = zip(*edge_indices)\n",
    "edge_list = [(a,b) for a,b in edge_list if not a == b] # remove self loops\n",
    "\n",
    "# generate graph from edge list\n",
    "G = nx.from_edgelist(edge_list, create_using=nx.DiGraph)\n",
    "\n",
    "layout = nx.spring_layout(G)\n",
    "nx.draw(G, layout, with_labels = True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d2e1331",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
